package com.tiny.tinyweb.core.utils;

import java.util.ArrayList;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 校验的工具类。
 *
 * @author zhang-m
 */
public class ValidaterUtils {

	/**
	 * 字母转换成数字
	 * @param pstr 字母
	 * @return 数字
	 */
	public static int kueToNumber(String pstr) {
		String pUpperCase = pstr.toUpperCase();
		char[] pKue = pUpperCase.trim().toCharArray();
		int rtnValue = 0;
		int multiplier = 0;
		for (int i = 0; i < pKue.length; i++) {
			multiplier = pKue[i] - 64;
			rtnValue += multiplier * Math.pow(26, i);
		}
		return rtnValue - 1;
	}

	/**
	 * null校验
	 * @param strValue 字符串值
	 * @param strNullFlg 1:不允许为空；0:允许为空
	 * @return false:失败；true:成功
	 */
	public static boolean nullCheck(String strValue, String strNullFlg) {
		boolean rtnValue = true;
		if ("1".equals(strNullFlg)) {
			if (strValue.isEmpty()) {
				rtnValue = false;
			}
		}
		return rtnValue;
	}

	/**
	 * 长度校验
	 * @param strValue 元字符串值
	 * @param strLength 长度
	 * @param strType 类型
	 * @return false:失败；true:成功
	 */
    public static boolean lengthCheck(String strValue, String strLength, String strType) {
        boolean rtnValue = true;
        try {
            if (strValue != null && !strValue.isEmpty()) {
                if (strType.equalsIgnoreCase("date") || strType.equalsIgnoreCase("timestamp")) {
                    return rtnValue;
                }
                String[] strArray = strLength.split(",");
                if (strType.equalsIgnoreCase("long") || strType.equalsIgnoreCase("number")) {
                    strValue = strValue.replace("-", "").replace("+", "");
                }
                if (strArray.length == 1) {
                    if (strValue.getBytes().length > Integer.valueOf(strLength)) {
                        rtnValue = false;
                    }
                } else {
                    String[] strArray1 = strValue.split("\\.");
                    if (strArray1.length > 1) {
                        if (strArray1[0].getBytes().length + strArray1[1].getBytes().length > Integer
                                .valueOf(strArray[0]) || strArray1[1].getBytes().length > Integer.valueOf(strArray[1])) {
                            rtnValue = false;
                        }
                    } else {
                        if (strValue.getBytes().length > Integer.valueOf(strArray[0])) {
                            rtnValue = false;
                        }
                    }
                }
            }
        } catch (Exception e) {
            rtnValue = false;
        }
        return rtnValue;
    }

	/**
	 * 类型校验
	 * @param strValue 元字符串值
	 * @param strType 类型
	 * @return false:失败；true:成功
	 */
    public static boolean typeCheck(String strValue, String strType) {
        boolean rtnValue = true;
        try {
            if (strValue != null && !strValue.isEmpty()) {
                if (strType.equalsIgnoreCase("char")) {
                    rtnValue = org.apache.commons.lang3.StringUtils.isAsciiPrintable(strValue);
                } else if (strType.equalsIgnoreCase("date")) {
                    rtnValue = (ConversionUtils.parseDate(strValue) != null);
                } else if (strType.equalsIgnoreCase("timestamp")) {
                    rtnValue = (ConversionUtils.parseDate(strValue) != null);
                } else if (strType.equalsIgnoreCase("long")) {
                    if (strValue.startsWith("-") || strValue.startsWith("+")) {
                        if (strValue.split("-").length > 2) {
                            rtnValue = false;
                        } else {
                            if (strValue.split("+").length > 2) {
                                rtnValue = false;
                            } else {
                                rtnValue = org.apache.commons.lang3.StringUtils.isNumeric(strValue.replace("-", "")
                                        .replace("+", ""));
                            }
                        }
                    } else {
                        rtnValue = org.apache.commons.lang3.StringUtils.isNumeric(strValue);
                    }
                } else if (strType.equalsIgnoreCase("number")) {
                    if (strValue.split("\\.").length > 2) {
                        rtnValue = false;
                    } else {
                        if (strValue.startsWith("-") || strValue.startsWith("+")) {
                            if (strValue.split("-").length > 2) {
                                rtnValue = false;
                            } else {
                                if (strValue.split("\\+").length > 2) {
                                    rtnValue = false;
                                } else {
                                    rtnValue = org.apache.commons.lang3.StringUtils.isNumeric(strValue.replace("-", "")
                                            .replace("+", "").replace(".", ""));
                                }
                            }
                        } else {
                            rtnValue = org.apache.commons.lang3.StringUtils.isNumeric(strValue.replace(".", ""));
                        }
                    }
                }
            }
        } catch (Exception e) {
            rtnValue = false;
        }
        return rtnValue;
    }

	/**
	 * 取值范围校验
	 * @param strValue 元字符串值
	 * @param strMax 最大值
	 * @param strMin 最小值
	 * @param strType 类型
	 * @return false:失败；true:成功
	 */
	public static boolean valueInCheck(String strValue, String strMax, String strMin, String strType) {
		boolean rtnValue = true;
		if (!strValue.isEmpty()) {
			try {
			    if (strType.equalsIgnoreCase("date") || strType.equalsIgnoreCase("timestamp")) {
			        Date dateValue = ConversionUtils.parseDate(strValue);
			        if (dateValue == null) {
			            rtnValue = false;
			        } else {
			            if (!strMin.isEmpty()) {
			                Date dateMin = ConversionUtils.parseDate(strMin);
			                if (dateValue.compareTo(dateMin) < 0) {
	                            rtnValue = false;
	                        }
			            }
			            if (!strMax.isEmpty()) {
			                Date dateMax = ConversionUtils.parseDate(strMax);
			                if (dateValue.compareTo(dateMax) > 0) {
                                rtnValue = false;
                            }
			            }
			        }
			    } else if (strType.equalsIgnoreCase("long")) {
			        Long lngVlaue = Long.parseLong(strValue);
			        if (!strMin.isEmpty()) {
			            Long lngMin = Long.parseLong(strMin);
			            if (lngVlaue.compareTo(lngMin) < 0) {
			                rtnValue = false;
			            }
			        }
			        if (!strMax.isEmpty()) {
			            Long lngMax = Long.parseLong(strMax);
			            if (lngVlaue.compareTo(lngMax) > 0) {
			                rtnValue = false;
			            }
			        }
			    } else if (strType.equalsIgnoreCase("number")) {
			        Double dblVlaue = Double.parseDouble(strValue);
			        if (!strMin.isEmpty()) {
			            Double dblMin = Double.parseDouble(strMin);
			            if (dblVlaue.compareTo(dblMin) < 0) {
			                rtnValue = false;
			            }
			        }
			        if (!strMax.isEmpty()) {
			            Double dblMax = Double.parseDouble(strMax);
			            if (dblVlaue.compareTo(dblMax) > 0) {
			                rtnValue = false;
			            }
			        }
			    } else {
	                if (!strMin.isEmpty()) {
	                    if (strValue.compareToIgnoreCase(strMin) < 0) {
	                        rtnValue = false;
	                    }
	                }
	                if (!strMax.isEmpty()) {
	                    if (strValue.compareToIgnoreCase(strMax) > 0) {
	                        rtnValue = false;
	                    }
	                }
			    }
			} catch (Exception e) {
				rtnValue = false;
			}
		}
		return rtnValue;
	}

	/**
	 * 分隔符转换
	 * @param strValue 元字符串
	 * @param strMinValue 最小值
	 * @param strMaxValue 最大值
	 * @return 转换后字符列表
	 */
	@SuppressWarnings("unused")
	public static ArrayList<String> dataSplit(String strValue,
			String strMinValue, String strMaxValue) {
		ArrayList<String> rtnArray = new ArrayList<String>();
		Pattern patternChk = null;
		Matcher matcherChk = null;
		if (strValue.isEmpty()
				|| Pattern.compile("^[~|～|\\-|－]+$").matcher(strValue).find()) {
			rtnArray.add("");
		} else if (Pattern.compile("^[0-9]+$").matcher(strValue).find()) {
			rtnArray.add(strValue);
		} else if (Pattern.compile("^[0-9]+[,|:|.]+[0-9]+$").matcher(strValue)
				.find()) {
			String[] strArray = strValue.replace(",", "%").replace(":", "%")
					.replace(".", "%").split("%");
			String tmp = "";
			for (int i = 0; i < strArray.length; i++) {
				if (!strArray[i].isEmpty()) {
					tmp = tmp + strArray[i] + ".";
				}
			}
			rtnArray.add(tmp.substring(0, tmp.length() - 1));
		} else if (Pattern.compile("^[(≥)|(＞)][＝]?[0-9\\.]+$")
				.matcher(strValue).find()) {
			rtnArray.add(strValue.replace("＞＝", "").replace("≥", "")
					.replace("＞", ""));
			rtnArray.add(strMaxValue);
		} else if (Pattern.compile("^[(≤)|(＜)][＝]?[0-9\\.]+$")
				.matcher(strValue).find()) {
			rtnArray.add(strMinValue);
			rtnArray.add(strValue.replace("＜＝", "").replace("≤", "")
					.replace("＜", ""));
		} else if (Pattern.compile("^[0-9\\.]+[~|～|\\-|－]+[0-9\\.]+$")
				.matcher(strValue).find()) {
			String[] strArray = strValue.replace("~", "%").replace("～", "%")
					.replace("-", "%").replace("－", "%").split("%");
			for (int i = 0; i < strArray.length; i++) {
				if (!strArray[i].isEmpty()) {
					rtnArray.add(strArray[i]);
				}
			}
		} else {
			rtnArray.add(strValue);
		}
		return rtnArray;
	}

	/**
	 * 获取字符串中的数字
	 * @param strValue 元字符串
	 * @return 数字列表
	 */
	public static ArrayList<String> dataSplit(String strValue) {
	    ArrayList<String> rtnArray = new ArrayList<String>();
	    Pattern patternChk = null;
	    Matcher matcherChk = null;
	    String strPattern = "[0-9]+[.]?[0-9]?";
	    patternChk = Pattern.compile(strPattern);
	    matcherChk = patternChk.matcher(strValue);
	    while (matcherChk.find()) {
	        if (matcherChk.group().endsWith(".")) {
	            rtnArray.add(matcherChk.group().substring(0, matcherChk.group().length() - 1));
	        } else {
	            rtnArray.add(matcherChk.group());
	        }
	    }
	    return rtnArray;
	}

	/**
	 * 获取list里面最大数
	 * @param objArylst 数据列表
	 * @return 最大数
	 */
	public static int maxIndex(ArrayList<Integer> objArylst) {

		Integer pValue = null;
		for (int i = 0; i < objArylst.size(); i++) {
			if (i == 0) {
				pValue = objArylst.get(i);
			} else {
				if (pValue < objArylst.get(i)) {
					pValue = objArylst.get(i);
				}
			}
		}
		return pValue.intValue();
	}

	public static boolean isEmptyAll(ArrayList<String> objArylst) {
	    boolean rtnValue = true;
	    for (int i = 0; i < objArylst.size(); i++) {
	        if (!StringUtils.toString(objArylst.get(i)).trim().isEmpty()) {
	            rtnValue = false;
	            break;
	        }
	    }
	    return rtnValue;
	}

	/**
	 * 判断字符串是否是数字
	 *
	 * @param str
	 * @return
	 */
	public static boolean isNumeric(String str) {
		Pattern pattern = Pattern.compile("[0-9]*");
		Matcher isNum = pattern.matcher(str);
		if (!isNum.matches()) {
			return false;
		}
		return true;
	}

	/**
	 * 功能：验证字符串长度是否符合要求，一个汉字等于两个字符
	 *
	 * @param strParameter
	 *            要验证的字符串
	 * @param limitLength
	 *            验证的长度
	 * @return 符合长度ture 超出范围false
	 */
	public static boolean validateStrByLength(String strParameter,
			int limitLength) {
		int temp_int = 0;
		byte[] b = strParameter.getBytes();

		for (int i = 0; i < b.length; i++) {
			if (b[i] >= 0) {
				temp_int = temp_int + 1;
			} else {
				temp_int = temp_int + 2;
				i++;
			}
		}

		if (temp_int > limitLength) {
			return false;
		} else {
			return true;
		}
	}

	/**
	 * 检查数字
	 *
	 * @return
	 */
	public static boolean checkNumber(String num) {
		return checkInteger(num) && checkFloat(num);
	}

	/**
	 * 检查整数
	 *
	 * @return
	 */
	public static boolean checkInteger(String num) {
		try {
			Integer.parseInt(num);
		} catch (NumberFormatException ex) {
			return false;
		}
		return true;
	}

	/**
	 * 检查浮点数
	 * @return
	 */
	public static boolean checkFloat(String num) {
		try {
			Float.parseFloat(num);
		} catch (NumberFormatException ex) {
			return false;
		}
		return true;
	}

	/**
	 * 验证目标值[m,n]是否在标准值[x,y]的范围之内。
	 * @param target 目标值[m,n]
	 * @param standard 标准值[x,y]
	 * @return true:OK, false:NG
	 */
	public static boolean checkRange(String target, String standard) {
	    if (target == null || target.isEmpty()) {
	        return true;
	    }
	    if (standard == null || standard.isEmpty()) {
	        return true;
	    }
	    String[] targets = target.split(",");
	    String[] standards = standard.split(",");

	    try {
	        if (targets.length == 1) {
	            return Integer.parseInt(targets[0]) <= Integer.parseInt(standards[0]);
	        } else {
	            return (Integer.parseInt(targets[0]) <= Integer.parseInt(standards[0])
	                    && Integer.parseInt(targets[1]) <= Integer.parseInt(standards[1]));
	        }
	    } catch (Exception e) {
	        return false;
	    }
	}

	/**
	 * 检查对象能否转化成数值
	 * @param strValue 目标对象
	 * @return true:OK, false:NG
	 */
	public static boolean checkDouble(String strValue) {
	    try {
            Double.parseDouble(strValue);
        } catch (Exception e) {
            return false;
        }
	    return true;
	}

	/**
	 * 全角转半角
	 * @param fullStr 目标字符串
	 * @return 转换后字符串
	 */
    public static String fullToHalf(String fullStr) {
        if (fullStr.isEmpty()) {
            return fullStr;
        }
        char[] c = fullStr.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] >= 65281 && c[i] <= 65374) {
                c[i] = (char) (c[i] - 65248);
            } else if (c[i] == 12288) { // 空格
                c[i] = (char) 32;
            }
        }
        return new String(c);
    }
}
